Please address the comments from this code review:

## Overall Comments
- The HTML for the preview link is embedded as a large inline string with inline styles; consider moving styling to CSS and building the markup via `format_html` (or a small template/utility) to improve readability and avoid unintended whitespace.
- In `DeclaredStaticAlias`, the new `placeholder_preview_link` field is set but not referenced elsewhere; if it's not needed for downstream consumers, you might remove it to keep the declaration minimal and avoid confusion.
- When generating the `href` with `admin_view_url(alias)` inside the f-string, using `format_html` for the whole link block would be safer and more consistent with Django’s escaping conventions rather than interpolating raw strings.

## Individual Comments

### Comment 1
<location> `tests/test_templatetags.py:454-461` </location>
<code_context>
+
+            request.toolbar.preview_mode_active = False
+
+        with self.subTest("preview-link enabled in edit-mode"):
+            output = self.render_template_obj(
+                alias_link_enabled_template,
+                {},
+                request,
+            )
+            self.assertNotEqual(alias_content, output)
+            self.assertIn(alias_preview_link, output)
+
+            # check that other "extra_bits" don't interfere with functionality
</code_context>

<issue_to_address>
**suggestion (testing):** Add a more specific assertion on the preview link element to ensure we’re testing the exact behavior and not just partial HTML.

Currently we only check that `alias_preview_link` is a substring of the rendered output. Please tighten this by asserting that the full `<a>` element is present with the expected CSS class, and that its `href` targets the alias admin/preview URL (e.g., contains the alias ID or a known path segment). This will make the test more robust and clearly specify the expected markup.

Suggested implementation:

```python
        with self.subTest("preview-link enabled in edit-mode"):
            output = self.render_template_obj(
                alias_link_enabled_template,
                {},
                request,
            )
            self.assertNotEqual(alias_content, output)
            # basic sanity check that the preview link markup is present
            self.assertIn(alias_preview_link, output)

            # assert that the full <a> element is rendered with the expected class and href
            preview_link_match = re.search(
                r'<a[^>]+class="[^"]*\bplaceholder_preview_link\b[^"]*"[^>]+href="(?P<href>[^"]+)"',
                output,
            )
            self.assertIsNotNone(
                preview_link_match,
                msg="Expected an <a> tag with class containing 'placeholder_preview_link' in the rendered output.",
            )
            preview_href = preview_link_match.group("href")
            self.assertIn(
                "/admin/cms/alias/",
                preview_href,
                msg="Preview link href should point to the alias admin preview URL.",
            )
            # ensure the href targets this specific alias
            self.assertIn(
                str(alias.pk),
                preview_href,
                msg="Preview link href should contain the alias primary key.",
            )

            # check that other "extra_bits" don't interfere with functionality
            output = self.render_template_obj(
                alias_link_enabled_template.replace(
                    "placeholder_preview_link",
                    "site placeholder_preview_link",
                ),
                {},
                request,
            )
            self.assertNotEqual(alias_content, output)
            # basic sanity check that the preview link markup is present
            self.assertIn(alias_preview_link, output)

            # assert that the full <a> element is still rendered correctly
            preview_link_match = re.search(
                r'<a[^>]+class="[^"]*\bplaceholder_preview_link\b[^"]*"[^>]+href="(?P<href>[^"]+)"',
                output,
            )
            self.assertIsNotNone(
                preview_link_match,
                msg=(
                    "Expected an <a> tag with class containing 'placeholder_preview_link' "
                    "in the rendered output when extra_bits are present."
                ),
            )
            preview_href = preview_link_match.group("href")
            self.assertIn(
                "/admin/cms/alias/",
                preview_href,
                msg="Preview link href should point to the alias admin preview URL.",
            )
            self.assertIn(
                str(alias.pk),
                preview_href,
                msg="Preview link href should contain the alias primary key.",
            )

```

1. Ensure `re` is imported at the top of `tests/test_templatetags.py`:
   - If not already present, add `import re`.
2. The above assertions assume an `alias` object (with `.pk`) is already available in the test method’s scope, which is typical for this kind of test. If the variable name differs (e.g., `alias_obj` or `self.alias`), replace `alias.pk` with the correct reference.
3. If the actual admin preview URL pattern differs from `/admin/cms/alias/`, adjust the `self.assertIn("/admin/cms/alias/", preview_href, ...)` check to match the real path segment used in your project’s URL configuration.
</issue_to_address>

### Comment 2
<location> `tests/test_templatetags.py:497-505` </location>
<code_context>
+
+            request.toolbar = toolbar
+
+        with self.subTest("preview-link hidden for anonymous user"):
+            anon_request = self.get_request("/")
+            anon_request.user = AnonymousUser()
+            output = self.render_template_obj(
+                alias_link_enabled_template,
+                {},
+                anon_request,
+            )
+            self.assertNotIn(alias_preview_link, output)
</code_context>

<issue_to_address>
**suggestion (testing):** Also assert the alias content is still rendered for anonymous users, not only that the link is hidden.

This only asserts that the preview link is absent. Please also assert that the alias content is present (e.g. `self.assertEqual(alias_content, output)` or a suitable containment check) so we verify the link is hidden without suppressing the content for anonymous users.
</issue_to_address>